Software Performance Engineering

Uplatz offers comprehensive training on Software Performance Engineering and Multicore Programming. This is a video-based online course (self-paced training). You will be awarded Course Completion Certificate at the end of the course.

Software Performance Engineering (SPE) is a systematic, quantitative approach to the cost-effective development of software systems to meet performance requirements. SPE is a software-oriented approach that focuses on architecture, design, and implementation choices.

SPE gives you the information you need to build software that meets performance requirements on time and within budget.

The SPE process begins early in the software development life cycle and uses quantitative methods to identify satisfactory designs and to eliminate those that are likely to have unacceptable performance before developers invest significant time in implementation. SPE continues through the detailed design, coding and performance and load testing phases to predict and manage the performance of the evolving software as well as monitor and report actual performance versus specifications and predictions. SPE methods encompass: performance data collection; quantitative performance analysis techniques; prediction strategies; management of uncertainties; data presentation and tracking; performance testing, stress and load testing, model verification and validation; critical success factors; and performance design principles, patterns and antipatterns.

SPE provides an engineering approach to performance, avoiding the extremes of performance-driven development and "fix-it-later." SPE uses model predictions to evaluate trade-offs in software functions versus hardware costs. The models assist developers in controlling resource requirements by selecting architecture and design alternatives with acceptable performance characteristics. They aid in tracking performance throughout the development process and prevent problems from surfacing late in the life cycle (typically during performance and stress testing).

Features of Software Performance Engineering

SPE is language and platform independent. Performance models are constructed from architectural and design-level information. Thus, SPE works with C++, C# and Java as well as with other object-oriented and non-object-oriented languages. The execution behavior of the software will be different with different languages and platforms. Nevertheless, this is reflected in the resource requirement specifications, not the model structure.

SPE uses deliberately simple models of software processing with the goal of using the simplest possible model that identifies problems with the system architecture, design, or implementation plans. It is relatively easy to construct and solve these models to determine whether the proposed software is likely to meet performance requirements. As the software development process proceeds, we refine the models to more closely represent the performance of the emerging software and re-evaluate performance.

SPE can be easily integrated into the software development process. It has been used with traditional process models, such as the waterfall model. It works especially well with iterative, incremental processes such as the Unified Process. With an iterative, incremental process, you can use SPE techniques to assess and reduce the risk of performance failure at the project outset, and at each subsequent iteration.

Benefits of SPE

• You can deliver that application on time and within budget while meeting your performance requirements - with the first release.
• You can know the hardware capacity requirements for your new application before it is developed.
• Architects know that their architecture will support performance requirements before committing to code.
• Project managers can track the status of performance while the software is being developed.
• Performance specialists have time to run performance tests, load and stress tests without encountering "surprises."
• Risks to achieving performance requirements are identified and addressed early in the process, saving both time and money.
• Software that meets performance requirements is delivered on time and within budget.

Thus, Software performance engineering provides a systematic, cost-effective approach to managing software systems performance. Use of SPE can reduce project costs and eliminate project failures due to performance problems. It can also improve your level of service to customers, reduce business costs, help you use computer resources more efficiently, and improve your competitive position. SPE is sensible, and it works!

• Software Performance Engineering and Multicore Programming - all lectures 11:03:26

  • 1: Software Performance Engineering 28:10
  • 2: Introduction to Multicore Programming 32:38
  • 3: Multithreaded Parallelism and Performance Measures 29:02
  • 4: Analysis of Multithreaded Algorithms 24:54
  • 5: Issues in Parallelization 14:01
  • 6: Synchronizing without Locks and Concurrent Data Structures 22:51
  • 7: Cache Complexity 29:19
  • 8: Around Montgomery's Trick 10:02
  • 9: Space vs Time and Cache vs Memory 19:13
  • 10: Experience in Coding High Performance Numerical Libraries 22:13
  • 11: FFT based Polynomial Arithmetic on Multicore 17:58
  • 12: Parallel Programming for Many Core Architectures 33:30
  • 13: Memory Hierarchy Optimization - part 1 28:30
  • 14: Memory Hierarchy Optimization - part 2 20:48
  • 15: Writing Correct Programs 37:57
  • 16: Floating Point and Linear Algebra 21:31
  • 17: Applications 14:14
  • 18: Dynamic Scheduling and Sorting 24:42
  • 19: Virtual Machines 28:13
  • 20: Hypervisor Architecture 23:06
  • 21: Multicore Computing 10:09
  • 22: Multicore Programming - part 1 40:45
  • 23: Multicore Programming - part 2 42:19
  • 24: Multicore Programming - part 3 36:47
  • 25: Multicore Programming - part 4 25:39
  • 26: Multicore Programming - part 5 24:55

Software Performance Engineering (SPE) and Multicore Programming - Course Syllabus

• Software Performance Engineering
• Introduction to Multicore Programming
• Multithreaded parallelism and Performance Measures
• Analysis of Multithreaded Algorithms
• Issues in Parallelization
• Synchronizing without locks and concurrent data structures
• Cache Complexity
• Montgomery Trick
• Space Vs Time Cache Vs Memory
• Experience in coding high performance numeric libraries
• FFT Based Polynomial Arithmetic on Multicore
• Parallel Programming for Many high-performance Architectures
• Memory Hierarchy Optimization-I
• Memory Hierarchy Optimization-II
• Writing Correct Programs
• Floating Point
• Applications
• Dynamic Scheduling Sorting
• Virtual Machines
• Hypervisor
• Multicore Computing
• Multicore Programming-I
• Multicore Programming-II
• Multicore Programming-III
• Multicore Programming-IV
• Multicore Programming-V

Everyone

Passion and zeal to learn and succeed!

• System Performance Engineer
• Software Engineer
• System Engineer & Analyst
• System Administrator
• Cloud Architect & Engineer
• Performance Engineer
• Senior Software Performance Analysis Engineer
• Software Tester
• Embedded Engineer
• Safety Performance Engineer
• Quality Assurance Lead
• Operational Performance Engineer
• Electronics & Communication Engineer
• Software Developer & Programmer

Currently there are no Q&As for this course. Be the first to ask a question.

Reed courses certificate of completion

Digital certificate - Included

Uplatz Certificate of Completion

Digital certificate - Included